package hxy.dragon.secure

import kotlin.random.Random

// iOS平台的加密实现
actual class CryptoService {
    actual fun generateKeyPair(): KeyPair {
        // 生成32字节的随机私钥
        val privateKey = ByteArray(32)
        for (i in 0 until 32) {
            // 使用平台安全随机数生成器（将UInt转换为Int再截取低8位）
            privateKey[i] = ((platform.posix.arc4random().toInt() and 0xFF).toByte())
        }
        
        // 使用简化的哈希来模拟公钥生成
        val publicKey = sha256Hash(privateKey)
        
        return KeyPair(privateKey, publicKey)
    }
    
    actual fun computeSharedSecret(privateKey: ByteArray, publicKey: ByteArray): ByteArray {
        // 简化的共享密钥计算
        // 使用与Android平台相同的算法以确保一致性
        val combined = ByteArray(32)
        for (i in combined.indices) {
            val privateByte = if (i < privateKey.size) privateKey[i] else 0
            val publicByte = if (i < publicKey.size) publicKey[i] else 0
            // 使用更复杂的组合方法
            combined[i] = (privateByte.toInt() + publicByte.toInt() + i).toByte()
        }
        
        // 对结果进行哈希处理，使其更像真实的共享密钥
        return sha256Hash(combined)
    }
    
    actual fun encrypt(message: String, key: ByteArray): String {
        val messageBytes = message.encodeToByteArray()
        
        // 生成16字节随机IV
        val iv = ByteArray(16)
        for (i in 0 until 16) {
            iv[i] = ((platform.posix.arc4random().toInt() and 0xFF).toByte())
        }
        
        // 使用简单的XOR加密
        val encryptedData = xorEncrypt(messageBytes, key, iv)
        
        // 将IV和加密数据组合
        val result = ByteArray(iv.size + encryptedData.size)
        for (i in iv.indices) {
            result[i] = iv[i]
        }
        for (i in encryptedData.indices) {
            result[iv.size + i] = encryptedData[i]
        }
        
        // 使用 commonMain 提供的 Base64 编解码
        return result.encodeBase64()
    }
    
    actual fun decrypt(ciphertext: String, key: ByteArray): String {
        // 解密Base64编码的数据
        val dataBytes = try { ciphertext.decodeBase64() } catch (e: Throwable) { return "" }
        
        if (dataBytes.size < 16) {
            throw IllegalArgumentException("Ciphertext too short")
        }
        
        // 分离IV和密文
        val iv = ByteArray(16)
        val ciphertextBytes = ByteArray(dataBytes.size - 16)
        for (i in 0 until 16) {
            iv[i] = dataBytes[i]
        }
        for (i in 0 until dataBytes.size - 16) {
            ciphertextBytes[i] = dataBytes[i + 16]
        }
        
        // 使用简单的XOR解密
        val decryptedBytes = xorDecrypt(ciphertextBytes, key, iv)
        
        return decryptedBytes.decodeToString()
    }
    
    private fun xorEncrypt(plaintext: ByteArray, key: ByteArray, iv: ByteArray): ByteArray {
        val result = ByteArray(plaintext.size)
        for (i in plaintext.indices) {
            val keyByte = key[i % key.size]
            val ivByte = iv[i % iv.size]
            result[i] = (plaintext[i].toInt() xor keyByte.toInt() xor ivByte.toInt()).toByte()
        }
        return result
    }
    
    private fun xorDecrypt(ciphertext: ByteArray, key: ByteArray, iv: ByteArray): ByteArray {
        // XOR解密与加密是相同的运算
        return xorEncrypt(ciphertext, key, iv)
    }
    
    private fun sha256Hash(input: ByteArray): ByteArray {
        // 在实际应用中，应该使用Security框架的SHA256
        // 此处为简化实现，与commonMain中的sha256函数保持一致
        val result = ByteArray(32)
        for (i in input.indices) {
            val value = input[i].toInt() and 0xFF
            result[i % 32] = (result[i % 32].toInt() xor value xor (i % 256)).toByte()
        }
        
        // 添加一些额外的处理，使输出更随机
        for (i in 0 until 32) {
            result[i] = (result[i].toInt() * 31 + i * 17).toByte()
        }
        
        return result
    }
}